home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 April / EnigmA AMIGA RUN 17 (1997)(G.R. Edizioni)(IT)[!][issue 1997-04][EAR-CD].iso / EARCD / biz / dbase / carcosts.lha / CarCosts / Source / Rexx.c < prev   
C/C++ Source or Header  |  1996-11-02  |  13KB  |  601 lines
  1. #include "demo.h"
  2. #include "Daten.h"
  3.  
  4.  LONG __saveds __asm getfuelnumber(register __a0 struct Hook *hook,
  5.                                    register __a2 struct Object *obj,
  6.                                    register __a1 LONG *a);
  7.  struct Hook getfuelnumberhook = 
  8.   {
  9.     {
  10.      NULL,NULL 
  11.     }
  12.    ,(VOID *)getfuelnumber,NULL,NULL 
  13.   };
  14.  LONG __saveds __asm getfuelnumber(register __a0 struct Hook *hook,
  15.                                    register __a2 struct Object *obj,
  16.                                    register __a1 LONG *a)
  17.   {
  18.    LONG max;
  19.    char buffer[30];
  20.    
  21.    get(LI_Treib, MUIA_List_Entries, &max);
  22.    sprintf(buffer, "%ld", max);
  23.    
  24.    set(obj, MUIA_Application_RexxString, buffer);
  25.    return(0);
  26.   }
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  LONG __saveds __asm getfuelinfo(register __a0 struct Hook *hook,
  38.                                  register __a2 struct Object *obj,
  39.                                  register __a1 LONG *(a[]));
  40.  struct Hook getfuelinfohook = 
  41.   {
  42.     {
  43.      NULL,NULL 
  44.     }
  45.    ,(VOID *)getfuelinfo,NULL,NULL 
  46.   };
  47.  LONG __saveds __asm getfuelinfo(register __a0 struct Hook *hook,
  48.                                  register __a2 struct Object *obj,
  49.                                  register __a1 LONG *(a[]))
  50.   {
  51.    LONG max, c;
  52.    struct NodeTreib *nt;
  53.    char buffer[30];
  54.    char *b;
  55.    
  56.    c = *(LONG *)a[1];
  57.    b = (char *)a[0];
  58.    
  59.    get(LI_Treib, MUIA_List_Entries, &max);
  60.    
  61.    if(c < max && c >= 0)
  62.     {
  63.      
  64.      DoMethod(LI_Treib, MUIM_List_GetEntry, c, &nt);
  65.      
  66.      
  67.      if(!strcmp(b,"DATE"))
  68.       {
  69.        ConvertToString(nt->Days, buffer);
  70.       }
  71.      else
  72.       {
  73.        if(!strcmp(b,"KM"))
  74.         {
  75.          sprintf(buffer, FORMAT_KILOMETER, nt->kmStand);
  76.         }
  77.        else
  78.         {
  79.          if(!strcmp(b,"LITER"))
  80.           {
  81.            sprintf(buffer, FORMAT_LITER, nt->Liter);
  82.           }
  83.          else
  84.           {
  85.            if(!strcmp(b,"PRICE"))
  86.             {
  87.              sprintf(buffer, FORMAT_PREIS, nt->Preis);
  88.             }
  89.            else
  90.             {
  91.              if(!strcmp(b,"DKM"))
  92.               {
  93.                sprintf(buffer, FORMAT_DKILOMETER, nt->deltakm);
  94.               }
  95.              else
  96.               {
  97.                if(!strcmp(b,"LPERKM"))
  98.                 {
  99.                  sprintf(buffer, FORMAT_VERBRAUCH, nt->Verbrauch);
  100.                 }
  101.                else
  102.                 {
  103.                  return(10);
  104.                 }
  105.               }
  106.             }
  107.           }
  108.         }
  109.       }
  110.      
  111.      
  112.      
  113.      set(obj, MUIA_Application_RexxString, buffer);
  114.      return(0);
  115.     }
  116.    else
  117.     {
  118.      return(10);
  119.     }
  120.   }
  121.  
  122.  
  123.  LONG __saveds __asm getsuppnumber(register __a0 struct Hook *hook,
  124.                                    register __a2 struct Object *obj,
  125.                                    register __a1 LONG *a);
  126.  struct Hook getsuppnumberhook = 
  127.   {
  128.     {
  129.      NULL,NULL 
  130.     }
  131.    ,(VOID *)getsuppnumber,NULL,NULL 
  132.   };
  133.  LONG __saveds __asm getsuppnumber(register __a0 struct Hook *hook,
  134.                                    register __a2 struct Object *obj,
  135.                                    register __a1 LONG *a)
  136.   {
  137.    LONG max;
  138.    char buffer[30];
  139.    
  140.    get(LI_Unter, MUIA_List_Entries, &max);
  141.    sprintf(buffer, "%ld", max);
  142.    
  143.    set(obj, MUIA_Application_RexxString, buffer);
  144.    return(0);
  145.   }
  146.  
  147.  
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.  
  155.  
  156.  LONG __saveds __asm getsuppinfo(register __a0 struct Hook *hook,
  157.                                  register __a2 struct Object *obj,
  158.                                  register __a1 LONG *(a[]));
  159.  struct Hook getsuppinfohook = 
  160.   {
  161.     {
  162.      NULL,NULL 
  163.     }
  164.    ,(VOID *)getsuppinfo,NULL,NULL 
  165.   };
  166.  LONG __saveds __asm getsuppinfo(register __a0 struct Hook *hook,
  167.                                  register __a2 struct Object *obj,
  168.                                  register __a1 LONG *(a[]))
  169.   {
  170.    LONG max, c;
  171.    struct NodeUnter *nu;
  172.    char buffer[3*MAXTEXTSTRING+1];
  173.    char *b;
  174.    
  175.    c = *(LONG *)a[1];
  176.    b = (char *)a[0];
  177.    
  178.    get(LI_Unter, MUIA_List_Entries, &max);
  179.    
  180.    if(c < max && c >= 0)
  181.     {
  182.      
  183.      DoMethod(LI_Unter, MUIM_List_GetEntry, c, &nu);
  184.      
  185.      
  186.      if(!strcmp(b,"DATE"))
  187.       {
  188.        ConvertToString(nu->Days, buffer);
  189.       }
  190.      else
  191.       {
  192.        if(!strcmp(b,"TITLE"))
  193.         {
  194.          strcpy(buffer, nu->Titelstring);
  195.         }
  196.        else
  197.         {
  198.          if(!strcmp(b,"REMARK"))
  199.           {
  200.            strcpy(buffer, nu->Bemerkungstring);
  201.           }
  202.          else
  203.           {
  204.            if(!strcmp(b,"PRICE"))
  205.             {
  206.              sprintf(buffer, FORMAT_DM, nu->Preis);
  207.             }
  208.            else
  209.             {
  210.              return(10);
  211.             }
  212.           }
  213.         }
  214.       }
  215.      
  216.      set(obj, MUIA_Application_RexxString, buffer);
  217.      return(0);
  218.     }
  219.    else
  220.     {
  221.      return(10);
  222.     }
  223.   }
  224.  
  225.  
  226.  
  227.  
  228.  LONG __saveds __asm getsummary(register __a0 struct Hook *hook,
  229.                                 register __a2 struct Object *obj,
  230.                                 register __a1 LONG *(a[]));
  231.  struct Hook getsummaryhook = 
  232.   {
  233.     {
  234.      NULL,NULL 
  235.     }
  236.    ,(VOID *)getsummary,NULL,NULL 
  237.   };
  238.  LONG __saveds __asm getsummary(register __a0 struct Hook *hook,
  239.                                 register __a2 struct Object *obj,
  240.                                 register __a1 LONG *(a[]))
  241.   {
  242.    char buffer[MAXTEXTSTRING];
  243.    char *b;
  244.    
  245.    
  246.    b = (char *)a[0];
  247.    
  248.    if(!strcmp(b,"STARTDATE"))
  249.     {
  250.      strcpy(buffer, Daten.SDatum);
  251.     }
  252.    else
  253.     {
  254.      if(!strcmp(b,"ENDDATE"))
  255.       {
  256.        strcpy(buffer, Daten.EDatum);
  257.       }
  258.      else
  259.       {
  260.        if(!strcmp(b,"LITER"))
  261.         {
  262.          sprintf(buffer, FORMAT_LITER, Daten.Liter);
  263.         }
  264.        else
  265.         {
  266.          if(!strcmp(b,"KM"))
  267.           {
  268.            sprintf(buffer, FORMAT_KILOMETER, Daten.Kilometer);
  269.           }
  270.          else
  271.           {
  272.            if(!strcmp(b,"CONSUMPTION"))
  273.             {
  274.              sprintf(buffer, FORMAT_VERBRAUCH, Daten.Verbrauch);
  275.             }
  276.            else
  277.             {
  278.              if(!strcmp(b,"PRICEFUEL"))
  279.               {
  280.                sprintf(buffer, FORMAT_DM, Daten.TreibGes);
  281.               }
  282.              else
  283.               {
  284.                if(!strcmp(b,"PRICESUPPORT"))
  285.                 {
  286.                  sprintf(buffer, FORMAT_DM, Daten.UnterGes);
  287.                 }
  288.                else
  289.                 {
  290.                  if(!strcmp(b, "SIGN"))
  291.                   {
  292.                    strcpy(buffer, Start_Kennzeichen);
  293.                   }
  294.                  else
  295.                   {
  296.                    if(!strcmp(b, "KMSTART"))
  297.                     {
  298.                      sprintf(buffer, FORMAT_KILOMETER, Start_KM);
  299.                     }
  300.                    else
  301.                     {
  302.                      return(10);
  303.                     }
  304.                   }
  305.                 }
  306.               }
  307.             }
  308.           }
  309.         }
  310.       }
  311.     }
  312.    set(obj, MUIA_Application_RexxString, buffer);
  313.    return(0);
  314.   }
  315.  
  316.  
  317.  
  318.  
  319.  LONG __saveds __asm setfuelentry(register __a0 struct Hook *hook,
  320.                                   register __a2 struct Object *obj,
  321.                                   register __a1 LONG *(a[]));
  322.  struct Hook setfuelentryhook = 
  323.   {
  324.     {
  325.      NULL,NULL 
  326.     }
  327.    ,(VOID *)setfuelentry,NULL,NULL 
  328.   };
  329.  LONG __saveds __asm setfuelentry(register __a0 struct Hook *hook,
  330.                                   register __a2 struct Object *obj,
  331.                                   register __a1 LONG *(a[]))
  332.   {
  333.    char buffer[MAXTEXTSTRING];
  334.    char *date, *km, *liter, *price;
  335.    LONG days, ret=0;
  336.    struct NodeTreib nt, *n=&nt;
  337.    BOOL update;
  338.    
  339.    
  340.    date  = (char *)a[0];
  341.    km    = (char *)a[1];
  342.    liter = (char *)a[2];
  343.    price = (char *)a[3];
  344.    update= (BOOL)  a[4];
  345.    
  346.    
  347.    strcpy(buffer, date);
  348.    /* Datum testen */
  349.    days = ConvertToDays(buffer);
  350.    if(days == -1) return(10); /* Datum nicht korrekt !!! */
  351.    
  352.    strcpy(nt.Datum, buffer);
  353.    nt.Days = days;
  354.    
  355.    sscanf(km   , "%ld", &nt.kmStand);
  356.    sscanf(liter, "%lf", &nt.Liter);
  357.    sscanf(price, "%lf", &nt.Preis);
  358.    
  359.    FillTreib(&nt);
  360.    
  361.    DoMethod(LI_Treib, MUIM_List_Insert, 
  362.             &n, 1, MUIV_List_Insert_Sorted);
  363.    
  364.    
  365.    /* Es wäre schön, das Datum, das zu einer negativen Distanz gehört, */
  366.    /* zurückgeben zu können. Dies scheint aber nicht möglich. Wenn ret */
  367.    /* ungleich 0 ist, wird kein String zurückgegeben.                  */
  368.    
  369.    if(update)
  370.     {
  371.      if(days = ReCalcTreib())
  372.       {
  373.      /* Negative Distanz */
  374.        ret = 5;
  375.       }
  376.     }
  377.    changes = TRUE;
  378.    return(ret);
  379.   }
  380.  
  381.  
  382.  
  383.  
  384.  
  385.  
  386.  LONG __saveds __asm setsupportentry(register __a0 struct Hook *hook,
  387.                                      register __a2 struct Object *obj,
  388.                                      register __a1 LONG *(a[]));
  389.  struct Hook setsupportentryhook = 
  390.   {
  391.     {
  392.      NULL,NULL 
  393.     }
  394.    ,(VOID *)setsupportentry,NULL,NULL 
  395.   };
  396.  LONG __saveds __asm setsupportentry(register __a0 struct Hook *hook,
  397.                                      register __a2 struct Object *obj,
  398.                                      register __a1 LONG *(a[]))
  399.   {
  400.    char buffer[MAXTEXTSTRING+1];
  401.    char *date, *title, *remark, *price;
  402.    LONG days;
  403.    struct NodeUnter nu, *n=ν
  404.    BOOL update;
  405.    
  406.    
  407.    date   = (char *)a[0];
  408.    title  = (char *)a[1];
  409.    remark = (char *)a[2];
  410.    price  = (char *)a[3];
  411.    update = (BOOL)  a[4];
  412.    
  413.    strcpy(buffer, date);
  414.    /* Datum testen */
  415.    days = ConvertToDays(buffer);
  416.    if(days == -1) return(10); /* Datum nicht korrekt !!! */
  417.    
  418.    strcpy(nu.Datum, buffer);
  419.    nu.Days = days;
  420.    
  421.    sscanf(price,"%lf",&nu.Preis);
  422.    sprintf(nu.Titelstring, FORMAT_TITEL, title);
  423.    sprintf(nu.Bemerkungstring, FORMAT_BEMERKUNG, remark);
  424.    
  425.    strcpy(buffer, nu.Titelstring);
  426.    buffer[MAX_TITEL] = 0;
  427.    strcpy(nu.DispTitel, buffer);
  428.    
  429.    strcpy(buffer, nu.Bemerkungstring);
  430.    buffer[MAX_REM] = 0;
  431.    strcpy(nu.DispRem, buffer);
  432.    
  433.    FillUnter(&nu);
  434.    
  435.    DoMethod(LI_Unter, MUIM_List_Insert, 
  436.             &n, 1, MUIV_List_Insert_Sorted);
  437.    
  438.    if(update)
  439.     {
  440.      ReCalcTreib(); /* Damit die aktuellen Werte angezeigt werden */
  441.     }
  442.    changes = TRUE;
  443.    
  444.    return(0);
  445.   }
  446.   
  447.   
  448.   
  449.   
  450.   
  451.  
  452.  LONG __saveds __asm setstart(register __a0 struct Hook *hook,
  453.                               register __a2 struct Object *obj,
  454.                               register __a1 LONG *(a[]));
  455.  struct Hook setstarthook = 
  456.   {
  457.     {
  458.      NULL,NULL 
  459.     }
  460.    ,(VOID *)setstart,NULL,NULL 
  461.   };
  462.  LONG __saveds __asm setstart(register __a0 struct Hook *hook,
  463.                               register __a2 struct Object *obj,
  464.                               register __a1 LONG *(a[]))
  465.   {
  466.    char buffer[50];
  467.    char * date, * car;
  468.    long * startkm, * datef, days;
  469.    BOOL ok;
  470.    
  471.    ok = TRUE;
  472.    
  473.    if(changes)
  474.     {
  475.      if(!MUI_Request(App, WI_Cost, 0, NULL, 
  476.                      TEXT(MSG_CLEAR_CONT_REQ),
  477.                      TEXT(MSG_NOTSAVED_NEW_REQ),
  478.                      TAG_END))
  479.       {
  480.        ok = FALSE;
  481.        ;
  482.       }
  483.     }
  484.    
  485.    if(ok) 
  486.     {
  487.      date   = (char *)a[0];
  488.      car    = (char *)a[1];
  489.      startkm= (long *)a[2];
  490.      datef  = (long *)a[3];
  491.      
  492.      strcpy(buffer, date);
  493.    /* Datum testen */
  494.      days = ConvertToDays(buffer);
  495.      if(days == -1) return(10); /* Datum nicht korrekt !!! */
  496.      
  497.      strcpy(Start_Datum, buffer);
  498.      Start_Day = days;
  499.      
  500.      Start_Format = *datef;
  501.      if(Start_Format < 0 || Start_Format > 4) Start_Format = 0;
  502.      
  503.      Start_KM     = *startkm;
  504.      strcpy(Start_Kennzeichen, car);
  505.      
  506.      RemoveAll();
  507.      changes     = FALSE;
  508.      FileName[0] = 0;
  509.      ReCalcTreib();
  510.     }
  511.    if(ok) return(0);
  512.    else   return(5);
  513.   }
  514.  
  515.  LONG __saveds __asm datetoint(register __a0 struct Hook *hook,
  516.                                register __a2 struct Object *obj,
  517.                                register __a1 LONG *(a[]));
  518.  struct Hook datetointhook = 
  519.   {
  520.     {
  521.      NULL,NULL 
  522.     }
  523.    ,(VOID *)datetoint,NULL,NULL 
  524.   };
  525.  LONG __saveds __asm datetoint(register __a0 struct Hook *hook,
  526.                                register __a2 struct Object *obj,
  527.                                register __a1 LONG *(a[]))
  528.   {
  529.    char buffer[50];
  530.    char * date;
  531.    long days;
  532.    BOOL ok;
  533.    
  534.    ok = TRUE;
  535.   
  536.    if(ok) 
  537.     {
  538.      date   = (char *)a[0];
  539.      
  540.      strcpy(buffer, date);
  541.      /* Datum testen */
  542.      days = ConvertToDays(buffer);
  543.      if(days == -1) return(10); /* Datum nicht korrekt !!! */
  544.      sprintf(buffer, "%ld", days);
  545.    
  546.      set(obj, MUIA_Application_RexxString, buffer);
  547.      }
  548.    if(ok) return(0);
  549.    else   return(5);
  550.   }
  551.  
  552.  
  553.  
  554.  struct MUI_Command commands[] =
  555.   {
  556.     {
  557.      "getfuelnumber", NULL, 0, &getfuelnumberhook     
  558.     }
  559.    ,
  560.     {
  561.      "getfuelinfo", "ITEM/A,NUMBER/N/A"   , 2        , &getfuelinfohook 
  562.     }
  563.    ,
  564.     {
  565.      "getsuppnumber", NULL, 0, &getsuppnumberhook     
  566.     }
  567.    ,
  568.     {
  569.      "getsuppinfo", "ITEM/A,NUMBER/N/A"   , 2        , &getsuppinfohook 
  570.     }
  571.    ,
  572.     {
  573.      "getsummary", "ITEM/A"   , 1        , &getsummaryhook 
  574.     }
  575.    ,
  576.     {
  577.      "setfuelentry", "DATE/A,KM/A,LITER/A,PRICE/A,UPDATE/S"   , 5        , &setfuelentryhook 
  578.     }
  579.    ,
  580.     {
  581.      "setsupportentry", "DATE/A,TITLE/A,REMARK/A,PRICE/A,UPDATE/S"   , 5        , &setsupportentryhook 
  582.     }
  583.    ,
  584.     {
  585.      "setstart", "DATE/A,CAR/A,STARTKM/N/A,DATEFORMAT/N/A"   , 4       
  586.      , &setstarthook
  587.     }
  588.    ,
  589.     {
  590.      "datetoint", "DATE/A"   , 1       
  591.      , &datetointhook
  592.     }
  593.    ,
  594.     {
  595.      NULL    , NULL          , NULL     , NULL     
  596.     }
  597.   };
  598.  
  599.  
  600.  
  601.